home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / X11 / wais / waisgate / ui.c < prev    next >
C/C++ Source or Header  |  1995-05-09  |  17KB  |  646 lines
  1. /* WIDE AREA INFORMATION SERVER SOFTWARE:
  2.    No guarantees or restrictions.  See the readme file for the full standard
  3.    disclaimer.
  4.  
  5.    Brewster@think.com
  6. */
  7.  
  8. #ifndef lint
  9. static char *RCSid = "$Header: /tmp_mnt/net/quake/proj/wais/wais-8-b5/ir/RCS/ui.c,v 1.16 92/03/18 09:01:09 jonathan Exp $";
  10. #endif
  11.  
  12. /* Change log:
  13.  * $Log:    ui.c,v $
  14.  * Revision 1.16  92/03/18  09:01:09  jonathan
  15.  * don't free DocObjs[0]->Type, it's a copy of the input!
  16.  * 
  17.  * Revision 1.15  92/03/06  12:53:03  jonathan
  18.  * Plug another memory leak.  From ericb@baker.dartmouth.edu (Eric J Bivona).
  19.  * 
  20.  * Revision 1.14  92/02/14  15:26:53  jonathan
  21.  * Conditionalized interpret_message and locally_answer_message so client need
  22.  * not include search engine.
  23.  * 
  24.  * Revision 1.13  92/02/12  13:53:41  jonathan
  25.  * Added "$Log" so RCS will put the log message in the header
  26.  * 
  27.  * 
  28. */
  29.  
  30. /* 
  31.  * this is a simple ui toolkit for building other ui's on top.
  32.  * -brewster
  33.  * 
  34.  * top level functions:
  35.  *   generate_search_apdu
  36.  *   generate_retrieval_apdu
  37.  *   interpret_message
  38.  *
  39.  */
  40.  
  41. /* to do:
  42.  *   generate multiple queries for long documents.
  43.  *     this will crash if the file being retrieved is larger than 100k.
  44.  *   
  45.  */
  46.  
  47. #include "ui.h"
  48. #include "wutil.h"
  49. #include "ustubs.h"
  50. #include "futil.h"
  51.  
  52. #include <ctype.h>
  53. #include <errno.h>
  54. #include <string.h>
  55. #include <sys/types.h>
  56.  
  57. /* returns a pointer in the buffer of the first free byte.
  58.    if it overflows, then NULL is returned 
  59.  */
  60. char *
  61. generate_search_apdu(buff,
  62.              buff_len,
  63.              seed_words,
  64.              database_name,
  65.              docobjs,
  66.              maxDocsRetrieved)
  67. char* buff;     /* buffer to hold the apdu */
  68. long *buff_len;    /* length of the buffer changed to reflect new data written */
  69. char *seed_words;    /* string of the seed words */
  70. char *database_name;
  71. DocObj** docobjs;
  72. long maxDocsRetrieved;
  73. {
  74.   /* local variables */
  75.  
  76.   SearchAPDU *search3;
  77.   char  *end_ptr;
  78.   static char *database_names[2] = {"", 0};
  79.   any refID;
  80.   WAISSearch *query;
  81.   refID.size = 1;
  82.   refID.bytes = "3";
  83.  
  84.   database_names[0] = database_name;
  85.   query = makeWAISSearch(seed_words,
  86.                          docobjs, /* DocObjsPtr */
  87.                          0L,
  88.                          1L,     /* DateFactor */
  89.                          0L,     /* BeginDateRange */
  90.                          0L,     /* EndDateRange */
  91.                          maxDocsRetrieved
  92.                          );
  93.  
  94.   search3 = makeSearchAPDU(30L, 
  95.                5000L, /* should be large */
  96.                30L,
  97.                            1L,    /* replace indicator */
  98.                            "",    /* result set name */
  99.                            database_names, /* database name */   
  100.                            QT_RelevanceFeedbackQuery, /* query_type */
  101.                            0L,   /* element name */
  102.                            NULL, /* reference ID */
  103.                            query);
  104.  
  105.   end_ptr = writeSearchAPDU(search3, buff, buff_len);
  106.  
  107.   CSTFreeWAISSearch(query);
  108.   freeSearchAPDU(search3);
  109.   return(end_ptr);
  110. }
  111.  
  112.  
  113. /* returns a pointer into the buffer of the next free byte.
  114.    if it overflowed, then NULL is returned
  115.  */
  116.  
  117. char *
  118.  generate_retrieval_apdu(buff,
  119.             buff_len,
  120.             docID,
  121.             chunk_type,
  122.             start,
  123.             end,
  124.             type,
  125.             database_name)
  126. char *buff;
  127. long *buff_len;    /* length of the buffer changed to reflect new data written */
  128. any *docID;
  129. long chunk_type;
  130. long start;
  131. long end;
  132. char *type;
  133. char *database_name;
  134. {
  135.   SearchAPDU *search;
  136.   char  *end_ptr;
  137.  
  138.   static char *database_names[2];
  139.   static char *element_names[3];
  140.   any refID;
  141.  
  142.   DocObj *DocObjs[2];
  143.   any *query;            /* changed from char* by brewster */
  144.  
  145.   if(NULL == type)
  146.     type = s_strdup("TEXT");
  147.  
  148.   database_names[0] = database_name;
  149.   database_names[1] = NULL;
  150.  
  151.   element_names[0] = " ";
  152.   element_names[1] = ES_DocumentText;
  153.   element_names[2] = NULL;
  154.  
  155.   refID.size = 1;
  156.   refID.bytes = "3";
  157.   
  158.   switch(chunk_type){
  159.   case CT_line: 
  160.     DocObjs[0] = makeDocObjUsingLines(docID, type, start, end);
  161.     break;
  162.   case CT_byte:
  163.     DocObjs[0] = makeDocObjUsingBytes(docID, type, start, end);
  164.     break;
  165.   }
  166.   DocObjs[1] = NULL;
  167.  
  168.   query = makeWAISTextQuery(DocObjs);   
  169.   search = makeSearchAPDU( 10L, 16L, 15L, 
  170.               1L,    /* replace indicator */
  171.               "FOO", /* result set name */
  172.               database_names, /* database name */   
  173.               QT_TextRetrievalQuery, /* query_type */
  174.               element_names, /* element name */
  175.               &refID, /* reference ID */
  176.               query);
  177.   end_ptr = writeSearchAPDU(search, buff, buff_len);
  178.   /* s_free(DocObjs[0]->Type); it's a copy of the input, don't free it! */
  179.   CSTFreeDocObj(DocObjs[0]);
  180.   CSTFreeWAISTextQuery(query);
  181.   freeSearchAPDU(search);
  182.   return(end_ptr);
  183. }
  184.  
  185. /* not currently used 
  186.  
  187. static boolean isnumber _AP((char* string));
  188.  
  189. static boolean isnumber(string)
  190. char *string;
  191. {
  192.   long count;
  193.   for(count = 0; count < strlen(string); count++){
  194.     if(!isdigit(string[count])){
  195.       return(false);
  196.     }
  197.   }
  198.   return(true);
  199. }
  200.  
  201. */
  202.  
  203. /* this will negotiate with server, and returs the maximum buffer size 
  204.    the server can handle.
  205.  
  206.    A connection should be established first using open_socket.
  207.  
  208. */
  209.  
  210. long init_connection(inBuffer, outBuffer, bufferSize, connection, userInfo)
  211. char *inBuffer, *outBuffer;
  212. long bufferSize;
  213. FILE *connection;
  214. char *userInfo;
  215. { 
  216.   InitAPDU* init = NULL;
  217.   InitResponseAPDU* reply = NULL;
  218.   long result;
  219.   /* construct an init */
  220.   init = makeInitAPDU(true,false,false,false,false,bufferSize,bufferSize,
  221.               userInfo,defaultImplementationID(),
  222.               defaultImplementationName(),
  223.               defaultImplementationVersion(),NULL,userInfo);
  224.   /* write it to the buffer */
  225.   result = writeInitAPDU(init,inBuffer+HEADER_LENGTH,&bufferSize) - inBuffer;
  226.  
  227.   if(result < 0){
  228.     freeInitAPDU(init);
  229.     return(-1);
  230.   }
  231.   if(0 ==
  232.      interpret_message(inBuffer,
  233.                result - HEADER_LENGTH,
  234.                outBuffer,
  235.                bufferSize,
  236.                connection,
  237.                false    /* true verbose */    
  238.                )) {
  239.     /* error making a connection */
  240.     return (-1);
  241.   }
  242.   if (readInitResponseAPDU(&reply,outBuffer + HEADER_LENGTH) == NULL){
  243.     freeWAISInitResponse((WAISInitResponse*)reply->UserInformationField);
  244.     freeInitResponseAPDU(reply);
  245.     return(-1);
  246.   }
  247.   if (reply->Result == false)
  248.     {                /* the server declined service */
  249.       freeWAISInitResponse((WAISInitResponse*)reply->UserInformationField);
  250.       freeInitResponseAPDU(reply);
  251.       return(-1);
  252.     }
  253.   else                /* we got a response back */
  254.     { result = reply->MaximumRecordSize;
  255.       freeWAISInitResponse((WAISInitResponse*)reply->UserInformationField);
  256.       freeInitResponseAPDU(reply);
  257.       return(result);
  258.     }
  259. }
  260.  
  261. #ifdef LOCAL_SEARCH
  262. /* returns the length of the response, 0 if an error */
  263. long
  264. locally_answer_message(request_message,
  265.                request_length,
  266.                response_message,
  267.                response_buffer_length)
  268. char *request_message;
  269. long request_length;
  270. char *response_message;
  271. long response_buffer_length;
  272. {
  273.   long request_length_internal = request_length;
  274.   long response_length;
  275.   WAISMessage header;
  276.   long maxBufferSize = response_buffer_length;
  277.  
  278.   readWAISPacketHeader(request_message, &header);
  279.   {
  280.     char length_array[11];
  281.     strncpy(length_array, header.msg_len, 10);
  282.     length_array[10] = '\0';
  283.     request_length_internal = atol(length_array);
  284.   }
  285.   /*
  286.     printf("request length is %ld (%ld from caller)\n", 
  287.     request_length_internal,
  288.     request_length);
  289.     */
  290.   
  291.   response_length =
  292.     interpret_buffer(request_message + HEADER_LENGTH, 
  293.              request_length_internal,
  294.              response_message + HEADER_LENGTH,
  295.              response_buffer_length,
  296.              &maxBufferSize,
  297.              (long)header.hdr_vers,
  298.              NULL);
  299.   if(0 > response_length)
  300.     return(0);
  301.   writeWAISPacketHeader(response_message,
  302.             response_length,
  303.             (long)'z',    /* Z39.50 */
  304.             "DowQuest  ", /* server name */
  305.             (long)NO_COMPRESSION,    /* no compression */
  306.             (long)NO_ENCODING,(long)header.hdr_vers);
  307.   return(response_length);
  308. }
  309. #endif
  310.  
  311. /* this is a safe version of unix 'read' it does all the checking
  312.  * and looping necessary
  313.  * to those trying to modify the transport code to use non-UNIX streams:
  314.  *  This is the function to modify!
  315.  */
  316. long read_from_stream(d,buf,nbytes)
  317. long d;                /* this is the stream */
  318. char *buf;
  319. long nbytes;
  320. {
  321.   long didRead;
  322.   long toRead = nbytes;
  323.   long totalRead = 0;        /* paranoia */
  324.  
  325.   while (toRead > 0){
  326.     didRead = read (d, buf, toRead);
  327.     if(didRead == -1)        /* error*/
  328.       return(-1);
  329.     if(didRead == 0)        /* eof */
  330.       return(-2);        /* maybe this should return 0? */
  331.     toRead -= didRead;
  332.     buf += didRead;
  333.     totalRead += didRead;
  334.   }
  335.   if(totalRead != nbytes)    /* we overread for some reason */
  336.     return(- totalRead);    /* bad news */    
  337.   return(totalRead);
  338. }
  339.  
  340. /* returns the length of the response, 0 if an error */
  341.  
  342. long 
  343. transport_message(connection,
  344.           request_message,
  345.           request_length,
  346.           response_message,
  347.           response_buffer_length)
  348. FILE *connection;
  349. char *request_message;
  350. long request_length;
  351. char *response_message;
  352. long response_buffer_length;
  353. {
  354.   WAISMessage header;
  355.   long response_length;
  356.  
  357.   
  358.   /* Write out message. Read back header. Figure out response length. */
  359.   
  360.   if( request_length + HEADER_LENGTH
  361.      != fwrite (request_message, 1L, request_length + HEADER_LENGTH, connection))
  362.     return 0;
  363.  
  364.   fflush(connection);
  365.  
  366.   /* read for the first '0' */
  367.  
  368.   while(1){
  369.     if(0 > read_from_stream(fileno(connection), response_message, 1))
  370.       return 0;
  371.     if('0' == response_message[0])
  372.       break;
  373.   }
  374.  
  375.   if(0 > read_from_stream(fileno(connection), 
  376.                   response_message + 1, 
  377.                   HEADER_LENGTH - 1))
  378.     return 0;
  379.  
  380.   readWAISPacketHeader(response_message, &header);
  381.   {
  382.     char length_array[11];
  383.     strncpy(length_array, header.msg_len, 10);
  384.     length_array[10] = '\0';
  385.     response_length = atol(length_array);
  386.     /*
  387.       if(verbose){
  388.       printf("WAIS header: '%s' length_array: '%s'\n", 
  389.       response_message, length_array);
  390.       }
  391.       */
  392.     if(response_length > response_buffer_length){
  393.       /* we got a message that is too long, therefore empty the message out,
  394.      and return 0 */
  395.       long i;
  396.       for(i = 0; i < response_length; i++){
  397.     read_from_stream(fileno(connection), 
  398.              response_message + HEADER_LENGTH,
  399.              1);
  400. /*    fread(response_message + HEADER_LENGTH, 1, 1, connection); */
  401.       }
  402.       return(0);
  403.     }
  404.   }
  405.   if(0 > read_from_stream(fileno(connection), 
  406.                   response_message + HEADER_LENGTH,
  407.                   response_length))
  408. /*  if(0 > fread(response_message + HEADER_LENGTH,
  409.            1, response_length, connection)) */
  410.     return 0;
  411.   return(response_length);
  412. }
  413.  
  414.  
  415. /* ------------------------------------------------------------*/
  416.  
  417. /*  Facility to record messages sent and recieved for testing 
  418.     and timing purposes. */
  419.  
  420. /* from c:
  421.  
  422.    putenv(strdup("IR_FILE=/users/menlo-park/brewster/tmp/infile"));
  423.  
  424.    from csh:
  425.  
  426.    setenv IR_FILE /users/menlo-park/brewster/tmp/infile
  427.  
  428.  */
  429.  
  430. boolean environment_variables_read = false; 
  431. char* ir_file_environment_variable = "IR_FILE";
  432. char* ir_file = NULL;
  433.  
  434. void read_environment_variables(host, port)
  435.      char* host;
  436.      char* port;
  437. {
  438.   
  439.   if(!environment_variables_read){
  440.     FILE *stream;
  441.     ir_file = (char*)getenv(ir_file_environment_variable);
  442.     if(ir_file){
  443.       printf("IR_file: %s\n", ir_file);
  444.       stream = fopen(ir_file, "w");
  445.       fprintf(stream, "%s %s\n", host, port);
  446.       fclose(stream);
  447.     }
  448.     environment_variables_read = true;
  449.   }
  450. }
  451.  
  452. /* returns 0 if success */
  453. long write_message_to_file(message, length, filename)
  454.      unsigned char *message;
  455.      long length;
  456.      char*filename;
  457. {
  458.   FILE *stream = fopen(filename, "a");
  459.   if(NULL == stream)
  460.     return(-1);
  461.   
  462.   printf("Writing to file: %s %d characters\n", filename, length);
  463.  
  464.   fprintf(stream, "---------------------------------\n");
  465.   
  466.   if(length != fwrite(message, sizeof(unsigned char), 
  467.               length, stream)){
  468.     perror("fwrite error");
  469.     fclose(stream);
  470.     return(-2);
  471.   }
  472.  
  473.   fprintf(stream, "\n");
  474.  
  475.   if(0 != fclose(stream))
  476.     return(-3);
  477.   return(0);
  478. }  
  479.  
  480. /* ------------------------------------------------------------*/
  481.  
  482. /* returns the number of bytes writeen.  0 if an error */
  483. long
  484. interpret_message(request_message,request_length,
  485.           response_message,
  486.           response_buffer_length,
  487.           connection,
  488.           verbose)
  489. char *request_message;
  490. long request_length; /* length of the buffer */
  491. char *response_message;
  492. long response_buffer_length;
  493. FILE *connection;
  494. boolean verbose;
  495. {
  496.   long response_length;
  497.  
  498.   writeWAISPacketHeader(request_message,
  499.             request_length,
  500.             (long)'z',    /* Z39.50 */
  501.             "wais      ", /* server name */
  502.             (long)NO_COMPRESSION,    /* no compression */
  503.             (long)NO_ENCODING,(long)HEADER_VERSION);
  504.  
  505.   if(ir_file){
  506.     long error_code;
  507.     if(0 != (error_code = 
  508.          write_message_to_file((unsigned char*)request_message, 
  509.                    request_length + HEADER_LENGTH, 
  510.                    ir_file)))
  511.       printf("Error writing log file Code: %d\n", error_code);
  512.   }
  513.     
  514.   if(connection != NULL) {
  515.     if(0 == 
  516.        (response_length =
  517.     transport_message(connection, request_message,
  518.               request_length,
  519.               response_message,
  520.               response_buffer_length)))
  521.       return(0);
  522.   }
  523.   else{
  524. #ifdef LOCAL_SEARCH    
  525.     if(0 == 
  526.        (response_length =
  527.     locally_answer_message(request_message, request_length, 
  528.                    response_message,
  529.                    response_buffer_length)))
  530.       return(0);
  531. #else
  532.     waislog(WLOG_HIGH, WLOG_ERROR, "Local search not supported in this version");
  533.     return(0);
  534. #endif
  535.   }
  536.   if(verbose){
  537.     printf ("decoded %ld bytes: \n", response_length);
  538.     twais_dsply_rsp_apdu(response_message + HEADER_LENGTH, 
  539.              request_length);
  540.   }
  541.   if(ir_file){
  542.     long error_code;
  543.     if(0 != (error_code = 
  544.          write_message_to_file((unsigned char*)response_message, 
  545.                    response_length + HEADER_LENGTH, 
  546.                    ir_file)))
  547.       printf("Error writing log file Code: %d\n", error_code);
  548.   }
  549.   return(response_length);
  550. }
  551.  
  552. /* this closes the connection to the socket.
  553.  * the mythology is that this is cleaner than exiting
  554.  */
  555.  
  556. long close_connection(connection)
  557. FILE *connection;
  558. {
  559.   long result = 0;
  560.   
  561.   if(connection != NULL){
  562.     result = fclose(connection);
  563.   }
  564.   return(result);
  565. }
  566.   
  567. void
  568. display_text_record_completely(record,quote_string_quotes)
  569. WAISDocumentText *record;
  570. boolean quote_string_quotes;
  571. {
  572.   long count;
  573.   /* printf(" Text\n");
  574.      print_any("     DocumentID:  ", record->DocumentID);
  575.      printf("     VersionNumber:  %d\n", record->VersionNumber);
  576.      */
  577.   for(count = 0; count < record->DocumentText->size; count++){
  578.     long ch = (unsigned char)record->DocumentText->bytes[count];
  579.     if(27 == ch){
  580.       /* then we have an escape code */
  581.       /* if the next letter is '(' or ')', then ignore two letters */
  582.       if('(' == record->DocumentText->bytes[count + 1] ||
  583.      ')' == record->DocumentText->bytes[count + 1])
  584.     count += 1;             /* it is a term marker */
  585.       else count += 4;        /* it is a paragraph marker */
  586.     }
  587.     else if (ch == '\t') /* a TAB! */
  588.       putc(ch, stdout);
  589.     else if (isprint(ch)){
  590.       if(quote_string_quotes && ch == '"')
  591.     putc('\\', stdout);
  592.       putc(ch, stdout);
  593.     } 
  594.     else if (ch == '\n' || ch == '\r')
  595.       printf ("\n");
  596.   }
  597. }
  598.  
  599. /* modifies the string to exclude all seeker codes. sets length to
  600.    the new length. */
  601. char *delete_seeker_codes(string,length)
  602. char *string;
  603. long *length;
  604. {
  605.   long original_count; /* index into the original string */
  606.   long new_count = 0; /* index into the collapsed string */
  607.   for(original_count = 0; original_count < *length; original_count++){
  608.     if(27 == string[original_count]){
  609.       /* then we have an escape code */
  610.       /* if the next letter is '(' or ')', then ignore two letters */
  611.       if('(' == string[original_count + 1] ||
  612.     ')' == string[original_count + 1])
  613.      original_count += 1;    /* it is a term marker */
  614.       else original_count += 4; /* it is a paragraph marker */
  615.     }
  616.     else string[new_count++] = string[original_count];
  617.   }
  618.   *length = new_count;
  619.   return(string);
  620. }
  621.   
  622.  
  623. /* returns a pointer to a string with good stuff */
  624. char *trim_junk(headline)
  625. char *headline;
  626. {
  627.   long length = strlen(headline) + 1; /* include the trailing null */
  628.   long i;
  629.   headline = delete_seeker_codes(headline, &length);
  630.   /* delete leading spaces */
  631.   for(i=0; i < strlen(headline); i++){
  632.     if(isprint(headline[i])){
  633.       break;
  634.     }
  635.   }
  636.   headline = headline + i;
  637.   /* delete trailing stuff */
  638.   for(i=strlen(headline) - 1 ; i > 0; i--){
  639.     if(isprint(headline[i])){
  640.       break;
  641.     }
  642.     headline[i] = '\0';
  643.   }
  644.   return(headline);
  645. }
  646.